import { read, utils } from 'xlsx'

/**
 * 解析合并单元格信息，返回rowspan 和 colspan
 * @param {Array} merges
 * @param {Number} row
 * @param {Number} col
 * @returns {{rowspan: Number, colspan: Number}}
 */
function resolveMerge(merges, row, col) {
    if (!merges) {
        return {
            rowspan: 1,
            colspan: 1,
        }
    }
    // 查找是不是合并开始的单元格
    const findMerge = merges.find(d => d.s.r === row && d.s.c === col)
    if (findMerge) {
        return {
            rowspan: findMerge.e.r - findMerge.s.r + 1,
            colspan: findMerge.e.c - findMerge.s.c + 1,
        }
    }
    // 查找是不是包含在合并的单元格中
    const inMerge = merges.find(d => row >= d.s.r && row <= d.e.r && col >= d.s.c && col <= d.e.c)
    if (inMerge) {
        return {
            rowspan: 0,
            colspan: 0,
        }
    }
    return {
        rowspan: 1,
        colspan: 1,
    }
}

/**
 * 获取单元格的值
 * 单元格的值可能有多种类型，根据不同类型做出处理
 * @param {Object} cell
 * @returns {String}
 */
function getCellValue(cell) {
    switch (cell.t) {
        case 's':
        case 'str':
        case 'inlineStr':
            return typeof cell.v === 'object' ? cell.v : cell.v.toString()
        case 'n' && cell.w: // 特殊处理数字但有格式化的w属性（可能是日期）
            return cell.w
        case 'n':
        case 'd':
            return cell.w || cell.v
        case 'b':
            return cell.v ? 'TRUE' : 'FALSE'
        default:
            return cell.v || '' // 对于未知类型或其他情况，直接展示v的值或空字符串
    }
}

/**
 * td渲染成超链接
 * @param {CellAddress} cell
 * @param {Object} config
 * @returns {Object}
 */
// function resolveHyperlink(cell, config = {}) {
//     const _this = this

//     return {
//         functional: true,
//         render(h) {
//             const td = (child, config = {}) => h('td', config, child)

//             try {
//                 if (cell.l) {
//                     const { Target, TargetMode } = cell.l.Rel
//                     if (TargetMode === 'Internal') {
//                         const mockA = (location, text) => [
//                             h(
//                                 'span',
//                                 {
//                                     class: 'mock-a',
//                                     on: {
//                                         click: () => _this.toggleSheet(location),
//                                     },
//                                 },
//                                 text
//                             ),
//                         ]
//                         // 跳转到其他sheet页
//                         if (Target.startsWith('#')) {
//                             if (Target.includes('!')) {
//                                 return td(
//                                     mockA(Target.slice(1, Target.indexOf('!')), cell.v),
//                                     config
//                                 )
//                             }
//                             return td(mockA(Target.slice(1), cell.v), config)
//                         }
//                         // 跳转到其他文档的，无法支持
//                         return td(cell.v, config)
//                     }
//                     if (TargetMode === 'External') {
//                         return td(
//                             h(
//                                 'a',
//                                 {
//                                     attrs: {
//                                         href: Target,
//                                         target: '_blank',
//                                     },
//                                 },
//                                 cell.v
//                             ),
//                             config
//                         )
//                     }
//                 }
//             } catch {}

//             return td(getCellValue(cell), config)
//         },
//     }
// }

function resolveCell(cell, config = {}) {
    /**
     * @type {Result}
     * @param isHyperlink 是否超链接
     * @param value 显示的值
     * @param location 超链接地址
     * @param mode 超链接跳转模式 内部Internal 外部External
     * @param hyperlinkType 类型 sheet间跳转-sheet 文档间跳转-doc
     */
    const result = {
        ...config,
        value: getCellValue(cell),
    }

    try {
        if (cell.l) {
            // 是超链接
            result.isHyperlink = true
            const { Target, TargetMode } = cell.l.Rel

            if (TargetMode === 'Internal') {
                // 内部跳转-sheet页间、文档间
                result.mode = 'Internal'
                // 跳转到其他sheet页
                if (Target.startsWith('#')) {
                    result.hyperlinkType = 'sheet'
                    if (Target.includes('!')) {
                        result.location = Target.slice(1, Target.indexOf('!'))
                        result.value = cell.v
                        return result
                    }
                    result.location = Target.slice(1)
                    result.value = cell.v
                    return result
                }
                result.hyperlinkType = 'doc'
                result.location = Target
                result.value = cell.v
                // 跳转到其他文档的，无法支持
                return result
            }

            if (TargetMode === 'External') {
                result.mode = 'External'
                result.location = Target
                result.value = cell.v
                return result
            }
        }
    } catch {}

    return result
}

// function toRender(sheet) {
//     const { resolveHyperlink } = this

//     if (!sheet['!ref']) {
//         return {
//             functional: true,
//             render(h) {
//                 return h('div')
//             },
//         }
//     }
//     // 将工作表数据解析为二维数组
//     const range = utils.decode_range(sheet['!ref']) // 获取工作表的范围
//     const merges = sheet['!merges'] // 获取合并单元格的范围

//     return {
//         functional: true,
//         render(h) {
//             const table = child => h('table', [child])
//             const tr = children => h('tr', children)
//             const trs = []

//             for (let rowNum = range.s.r; rowNum <= range.e.r; rowNum++) {
//                 const cells = []
//                 for (let colNum = range.s.c; colNum <= range.e.c; colNum++) {
//                     const { rowspan, colspan } = resolveMerge(merges, rowNum, colNum)
//                     if (rowspan > 0 && colspan > 0) {
//                         const cellAddress = utils.encode_cell({ r: rowNum, c: colNum })
//                         const cell = sheet[cellAddress]
//                         if (cell) {
//                             cells.push(
//                                 resolveHyperlink(cell, {
//                                     attrs: {
//                                         rowspan,
//                                         colspan,
//                                     },
//                                 })
//                             )
//                         } else {
//                             cells.push({
//                                 functional: true,
//                                 render: h =>
//                                     h('td', {
//                                         attrs: { colspan, rowspan },
//                                     }),
//                             })
//                         }
//                     }
//                 }
//                 if (cells.length) {
//                     trs.push(tr(cells.map(cell => h(cell))))
//                 }
//             }

//             return table(h('tbody', trs))
//         },
//     }
// }

/**
 * 解析excel sheet数据
 * @param {Sheet} sheet
 * @returns {Array<any>}
 */
function resolveSheet(sheet) {
    if (!sheet['!ref']) {
        return []
    }
    // 将工作表数据解析为二维数组
    const range = utils.decode_range(sheet['!ref']) // 获取工作表的范围
    const merges = sheet['!merges'] // 获取合并单元格的范围

    const trs = []
    for (let rowNum = range.s.r; rowNum <= range.e.r; rowNum++) {
        const cells = []
        for (let colNum = range.s.c; colNum <= range.e.c; colNum++) {
            const { rowspan, colspan } = resolveMerge(merges, rowNum, colNum)
            if (rowspan > 0 && colspan > 0) {
                const cellAddress = utils.encode_cell({ r: rowNum, c: colNum })
                const cell = sheet[cellAddress]
                if (cell) {
                    cells.push(
                        resolveCell(cell, {
                            rowspan,
                            colspan,
                        })
                    )
                } else {
                    cells.push({ colspan, rowspan })
                }
            }
        }
        if (cells.length > 0) {
            trs.push(cells)
        }
    }

    return trs
}

/**
 * 解析excel数据
 * @param {File} file
 * @returns {Array<{ name, list: Array<{any}> }>}
 */
export default async function resolveExcel(file) {
    const readStartTime = performance.now()
    const workBook = read(await new Blob([file], { type: 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet' }).arrayBuffer(), {
        type: 'array',
    })
    const readEndTime = performance.now()
    // eslint-disable-next-line no-console
    console.log('读取耗时:', readEndTime - readStartTime, '毫秒')

    // 只处理一个sheet
    return [
        {
            name: workBook.SheetNames[0],
            list: resolveSheet(workBook.Sheets[workBook.SheetNames[0]]),
            // component: this.toRender(workBook.Sheets[sheetName]),
        },
    ]
    // return workBook.SheetNames.map(sheetName => ({
    //     name: sheetName,
    //     list: resolveSheet(workBook.Sheets[sheetName]),
    //     // component: this.toRender(workBook.Sheets[sheetName]),
    // }))
}
